home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / pc / files / dsp / a56_10sh.z / a56_10sh / a56.l < prev    next >
Text File  |  1996-06-25  |  9KB  |  261 lines
  1. %{
  2. /*
  3.  * Copyright (C) 1990, 1991 Quinn C. Jensen
  4.  *
  5.  * Permission to use, copy, modify, distribute, and sell this software
  6.  * and its documentation for any purpose is hereby granted without fee,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.  The author makes no representations
  10.  * about the suitability of this software for any purpose.  It is
  11.  * provided "as is" without express or implied warranty.
  12.  *
  13.  */
  14. %}
  15. %a    10000
  16. %o    10000
  17. %e    2000
  18. %k    2000
  19. %p    3000
  20. A    [Aa]
  21. B    [Bb]
  22. C    [Cc]
  23. D    [Dd]
  24. E    [Ee]
  25. F    [Ff]
  26. G    [Gg]
  27. H    [Hh]
  28. I    [Ii]
  29. J    [Jj]
  30. K    [Kk]
  31. L    [Ll]
  32. M    [Mm]
  33. N    [Nn]
  34. O    [Oo]
  35. P    [Pp]
  36. Q    [Qq]
  37. R    [Rr]
  38. S    [Ss]
  39. T    [Tt]
  40. U    [Uu]
  41. V    [Vv]
  42. W    [Ww]
  43. X    [Xx]
  44. Y    [Yy]
  45. Z    [Zz]
  46. WHITE    [ \t]+
  47. ALCHR    [_A-Za-z]
  48. ALPHA    {ALCHR}+
  49. NUM    [0-9]+
  50. FRAC    ("-"|"")({NUM}"."{NUM})|("."{NUM})
  51. ALNUM    {ALCHR}[0-9A-Za-z_]*
  52. HEXNUM    [0-9A-Fa-f]+
  53. BW    (^|{WHITE})
  54. %%
  55. {WHITE}            ;
  56. \n            {curline++; RET(EOL);}
  57. @            {RET(EOS);}
  58. ^#.*$            |
  59. ;.*$            {RET(COMMENT);}
  60. {X}:            {RET(XMEM);}
  61. {Y}:            {RET(YMEM);}
  62. {L}:            {RET(LMEM);}
  63. {P}:            {RET(PMEM);}
  64. {A}10            {RET(A10);}
  65. {A}            {RET(AAAA);}
  66. {B}10            {RET(B10);}
  67. {B}            {RET(BBBB);}
  68. {A}{B}            {RET(AABB);}
  69. {B}{A}            {RET(BBAA);}
  70. {X}            {RET(XXXX);}
  71. {Y}            {RET(YYYY);}
  72. {S}{R}            {RET(SR);}
  73. {M}{R}            {RET(MR);}
  74. {C}{C}{R}        {RET(CCR);}
  75. {O}{M}{R}        {RET(OMR);}
  76. {S}{P}            {RET(SP);}
  77. {S}{S}{H}        {RET(SSH);}
  78. {S}{S}{L}        {RET(SSL);}
  79. {L}{A}            {RET(LA);}
  80. {L}{C}            {RET(LC);}
  81. {A}[0-2]        {yylval.ival = atoi(&yytext[1]); RET(AREG);}
  82. {B}[0-2]        {yylval.ival = atoi(&yytext[1]); RET(BREG);}
  83. {M}[0-7]        {yylval.ival = atoi(&yytext[1]); RET(MREG);}
  84. {N}[0-7]        {yylval.ival = atoi(&yytext[1]); RET(NREG);}
  85. {R}[0-7]        {yylval.ival = atoi(&yytext[1]); RET(RREG);}
  86. {X}[01]            {yylval.ival = atoi(&yytext[1]); RET(XREG);}
  87. {Y}[01]            {yylval.ival = atoi(&yytext[1]); RET(YREG);}
  88. "$"{HEXNUM}        {yylval.ival = strtol(&yytext[1], 0, 16); RET(CHEX);}
  89. {FRAC}            {yylval.ival = makefrac(yytext); RET(FRAC);}
  90. {NUM}            {yylval.ival = atoi(&yytext[0]); RET(CDEC);}
  91. {A}{B}{S}               {RET(OP_ABS);}
  92. {A}{D}{C}               {RET(OP_ADC);}
  93. {A}{D}{D}               {RET(OP_ADD);}
  94. {A}{D}{D}{L}            {RET(OP_ADDL);}
  95. {A}{D}{D}{R}            {RET(OP_ADDR);}
  96. {A}{S}{L}               {RET(OP_ASL);}
  97. {A}{S}{R}               {RET(OP_ASR);}
  98. {C}{L}{R}               {RET(OP_CLR);}
  99. {C}{M}{P}               {RET(OP_CMP);}
  100. {C}{M}{P}{M}            {RET(OP_CMPM);}
  101. {D}{I}{V}               {RET(OP_DIV);}
  102. {M}{A}{C}               {RET(OP_MAC);}
  103. {M}{A}{C}{R}            {RET(OP_MACR);}
  104. {M}{P}{Y}               {RET(OP_MPY);}
  105. {M}{P}{Y}{R}            {RET(OP_MPYR);}
  106. {N}{E}{G}               {RET(OP_NEG);}
  107. {N}{O}{R}{M}            {RET(OP_NORM);}
  108. {R}{N}{D}               {RET(OP_RND);}
  109. {S}{B}{C}               {RET(OP_SBC);}
  110. {S}{U}{B}               {RET(OP_SUB);}
  111. {S}{U}{B}{L}            {RET(OP_SUBL);}
  112. {S}{U}{B}{R}            {RET(OP_SUBR);}
  113. {T}{H}{S}               {yylval.cond = 0x0; RET(OP_TCC);}
  114. {T}{G}{E}               {yylval.cond = 0x1; RET(OP_TCC);}
  115. {T}{N}{E}               {yylval.cond = 0x2; RET(OP_TCC);}
  116. {T}{P}{L}               {yylval.cond = 0x3; RET(OP_TCC);}
  117. {T}{N}{N}               {yylval.cond = 0x4; RET(OP_TCC);}
  118. {T}{E}{C}               {yylval.cond = 0x5; RET(OP_TCC);}
  119. {T}{L}{C}               {yylval.cond = 0x6; RET(OP_TCC);}
  120. {T}{G}{T}               {yylval.cond = 0x7; RET(OP_TCC);}
  121. {T}{C}{S}               {yylval.cond = 0x8; RET(OP_TCC);}
  122. {T}{L}{O}               {yylval.cond = 0x8; RET(OP_TCC);}
  123. {T}{L}{T}               {yylval.cond = 0x9; RET(OP_TCC);}
  124. {T}{E}{Q}               {yylval.cond = 0xA; RET(OP_TCC);}
  125. {T}{M}{I}               {yylval.cond = 0xB; RET(OP_TCC);}
  126. {T}{N}{R}               {yylval.cond = 0xC; RET(OP_TCC);}
  127. {T}{E}{S}               {yylval.cond = 0xD; RET(OP_TCC);}
  128. {T}{L}{S}               {yylval.cond = 0xE; RET(OP_TCC);}
  129. {T}{L}{E}               {yylval.cond = 0xF; RET(OP_TCC);}
  130. {T}{F}{R}               {RET(OP_TFR);}
  131. {T}{S}{T}               {RET(OP_TST);}
  132. {A}{N}{D}               {RET(OP_AND);}
  133. {A}{N}{D}{I}            {RET(OP_ANDI);}
  134. {E}{O}{R}               {RET(OP_EOR);}
  135. {L}{S}{L}               {RET(OP_LSL);}
  136. {L}{S}{R}               {RET(OP_LSR);}
  137. {N}{O}{T}               {RET(OP_NOT);}
  138. {O}{R}                  {RET(OP_OR);}
  139. {O}{R}{I}               {RET(OP_ORI);}
  140. {R}{O}{L}               {RET(OP_ROL);}
  141. {R}{O}{R}               {RET(OP_ROR);}
  142. {B}{C}{L}{R}            {RET(OP_BCLR);}
  143. {B}{S}{E}{T}            {RET(OP_BSET);}
  144. {B}{C}{H}{G}            {RET(OP_BCHG);}
  145. {B}{T}{S}{T}            {RET(OP_BTST);}
  146. {D}{O}                  {RET(OP_DO);}
  147. {E}{N}{D}{D}{O}         {RET(OP_ENDDO);}
  148. {L}{U}{A}               {RET(OP_LUA);}
  149. {M}{O}{V}{E}            {RET(OP_MOVE);}
  150. {M}{O}{V}{E}{C}         {RET(OP_MOVEC);}
  151. {M}{O}{V}{E}{M}         {RET(OP_MOVEM);}
  152. {M}{O}{V}{E}{P}         {RET(OP_MOVEP);}
  153. {I}{N}{C}{L}{U}{D}{E}   {RET(OP_INCLUDE);}
  154. {I}{L}{L}{E}{G}{A}{L}   {RET(OP_ILLEGAL);}
  155. {J}{H}{S}               {yylval.cond = 0x0; RET(OP_JCC);}
  156. {J}{G}{E}               {yylval.cond = 0x1; RET(OP_JCC);}
  157. {J}{N}{E}               {yylval.cond = 0x2; RET(OP_JCC);}
  158. {J}{P}{L}               {yylval.cond = 0x3; RET(OP_JCC);}
  159. {J}{N}{N}               {yylval.cond = 0x4; RET(OP_JCC);}
  160. {J}{E}{C}               {yylval.cond = 0x5; RET(OP_JCC);}
  161. {J}{L}{C}               {yylval.cond = 0x6; RET(OP_JCC);}
  162. {J}{G}{T}               {yylval.cond = 0x7; RET(OP_JCC);}
  163. {J}{C}{S}               {yylval.cond = 0x8; RET(OP_JCC);}
  164. {J}{L}{O}               {yylval.cond = 0x8; RET(OP_JCC);}
  165. {J}{L}{T}               {yylval.cond = 0x9; RET(OP_JCC);}
  166. {J}{E}{Q}               {yylval.cond = 0xA; RET(OP_JCC);}
  167. {J}{M}{I}               {yylval.cond = 0xB; RET(OP_JCC);}
  168. {J}{N}{R}               {yylval.cond = 0xC; RET(OP_JCC);}
  169. {J}{E}{S}               {yylval.cond = 0xD; RET(OP_JCC);}
  170. {J}{L}{S}               {yylval.cond = 0xE; RET(OP_JCC);}
  171. {J}{L}{E}               {yylval.cond = 0xF; RET(OP_JCC);}
  172. {J}{M}{P}               {RET(OP_JMP);}
  173. {J}{C}{L}{R}            {RET(OP_JCLR);}
  174. {J}{S}{E}{T}            {RET(OP_JSET);}
  175. {J}{S}{H}{S}            {yylval.cond = 0x0; RET(OP_JSCC);}
  176. {J}{S}{G}{E}            {yylval.cond = 0x1; RET(OP_JSCC);}
  177. {J}{S}{N}{E}            {yylval.cond = 0x2; RET(OP_JSCC);}
  178. {J}{S}{P}{L}            {yylval.cond = 0x3; RET(OP_JSCC);}
  179. {J}{S}{N}{N}            {yylval.cond = 0x4; RET(OP_JSCC);}
  180. {J}{S}{E}{C}            {yylval.cond = 0x5; RET(OP_JSCC);}
  181. {J}{S}{L}{C}            {yylval.cond = 0x6; RET(OP_JSCC);}
  182. {J}{S}{G}{T}            {yylval.cond = 0x7; RET(OP_JSCC);}
  183. {J}{S}{C}{S}            {yylval.cond = 0x8; RET(OP_JSCC);}
  184. {J}{S}{L}{O}            {yylval.cond = 0x8; RET(OP_JSCC);}
  185. {J}{S}{L}{T}            {yylval.cond = 0x9; RET(OP_JSCC);}
  186. {J}{S}{E}{Q}            {yylval.cond = 0xA; RET(OP_JSCC);}
  187. {J}{S}{M}{I}            {yylval.cond = 0xB; RET(OP_JSCC);}
  188. {J}{S}{N}{R}            {yylval.cond = 0xC; RET(OP_JSCC);}
  189. {J}{S}{E}{S}            {yylval.cond = 0xD; RET(OP_JSCC);}
  190. {J}{S}{L}{S}            {yylval.cond = 0xE; RET(OP_JSCC);}
  191. {J}{S}{L}{E}            {yylval.cond = 0xF; RET(OP_JSCC);}
  192. {J}{S}{R}               {RET(OP_JSR);}
  193. {J}{S}{C}{L}{R}         {RET(OP_JSCLR);}
  194. {J}{S}{S}{E}{T}         {RET(OP_JSSET);}
  195. {N}{O}{P}               {RET(OP_NOP);}
  196. {R}{E}{P}               {RET(OP_REP);}
  197. {R}{E}{S}{E}{T}         {RET(OP_RESET);}
  198. {R}{T}{I}               {RET(OP_RTI);}
  199. {R}{T}{S}               {RET(OP_RTS);}
  200. {S}{T}{O}{P}            {RET(OP_STOP);}
  201. {S}{W}{I}               {RET(OP_SWI);}
  202. {W}{A}{I}{T}            {RET(OP_WAIT);}
  203. {E}{Q}{U}               {RET(OP_EQU);}
  204. {O}{R}{G}               {RET(OP_ORG);}
  205. {D}{C}                  {RET(OP_DC);}
  206. {E}{N}{D}               {RET(OP_END);}
  207. {P}{A}{G}{E}            {RET(OP_PAGE);}
  208. {P}{S}{E}{C}{T}         {RET(OP_PSECT);}
  209. {ALNUM}            {yylval.sval = strsave(yytext); RET(SYM);};
  210. '\\b'            {yylval.cval = '\b'; RET(CHAR);};
  211. '\\f'            {yylval.cval = '\f'; RET(CHAR);};
  212. '\\n'            {yylval.cval = '\n'; RET(CHAR);};
  213. '\\r'            {yylval.cval = '\r'; RET(CHAR);};
  214. '\\t'            {yylval.cval = '\t'; RET(CHAR);};
  215. '\\\\'            {yylval.cval = '\\'; RET(CHAR);};
  216. '.'            {yylval.cval = yytext[1]; RET(CHAR);};
  217. '..+'            {yylval.sval = (char *)fixstring(yytext);
  218.                 yylval.sval = strsave(yylval.sval);
  219.                 RET(STRING);};
  220. "<<"            {RET(SHL);};
  221. ">>"            {RET(SHR);};
  222. .            {RET(yytext[0]);}
  223. %%
  224.  
  225. #undef input
  226. #define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):lgetc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  227.  
  228. #define INLINE 1024
  229.  
  230. char inline[INLINE], *ip = NULL;
  231.  
  232. lgetc(fp)
  233. FILE *fp;
  234. {
  235.     int c;
  236.  
  237.     if(NOT ip) {
  238.     if(NOT fgets(inline, INLINE, fp))
  239.         return(EOF);
  240.     rmcr(inline);
  241.     ip = inline;
  242.     }
  243.     c = *ip;
  244.  
  245.     if(ldebug) {
  246.     printf("i='%c'(%x)", c, c);
  247.     fflush(stdout);
  248.     }
  249.  
  250.     switch(c) {
  251.     case '\0':
  252.         c = '\n';
  253.         ip = NULL;
  254.         break;
  255.     default:
  256.         ip++;
  257.         break;
  258.     }
  259.     return(c);
  260. }
  261.